home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / cmdity / yk212src.lha / Yak_2.12_Src / Prefs / gui.c < prev    next >
C/C++ Source or Header  |  1995-11-29  |  18KB  |  831 lines
  1. /*
  2.  * GUI.c
  3.  * 
  4.  * Contains high level common functions used by all the windows of Yak GUI
  5.  * 
  6.  */
  7.  
  8. #include <exec/execbase.h>
  9. #include <exec/types.h>
  10. #include <exec/memory.h>
  11. #include <diskfont/diskfont.h>
  12. #include <graphics/text.h>
  13. #include <intuition/intuition.h>
  14. #include <intuition/intuitionbase.h>
  15. #include <libraries/gadtools.h>
  16. #include <workbench/workbench.h>
  17.  
  18. #include <proto/exec.h>
  19. #include <proto/diskfont.h>
  20. #include <proto/dos.h>
  21. #include <proto/intuition.h>
  22. #include <proto/gadtools.h>
  23. #include <proto/graphics.h>
  24. #include <proto/wb.h>
  25.  
  26. #include <string.h>
  27.  
  28. #ifdef MUI
  29. #include <libraries/mui.h>
  30. #include <proto/muimaster.h>
  31. #endif
  32.  
  33. #ifdef BGUI
  34. #include <libraries/bgui.h>
  35. #include <libraries/bgui_macros.h>
  36. #include <proto/bgui.h>
  37. #include <clib/alib_protos.h>
  38. #endif
  39.  
  40. #include "Code.h"
  41. #include "yak.h"
  42. #include "version.h"
  43. #include "GetPubScreen.h"
  44. #include "GetScreenBox.h"
  45. #include "Hotkey_types.h"
  46. #include "Root_window.h"
  47. #include "MouseCycling_window.h"
  48. #include "Options_window.h"
  49. #include "KeyDef_window.h"
  50. #include "Blank_window.h"
  51. #include "Misc_window.h"
  52. #include "Hotkey_window.h"
  53. #include "DigitalClock_window.h"
  54. #include "Requesters.h"
  55. #include "Settings.h"
  56. #include "gui.h"
  57.  
  58. #include "yak_locale_strings.h"
  59.  
  60. IMPORT struct MsgPort *AppMsgPort;
  61.  
  62. #ifdef BETA_VERSION
  63. static UBYTE DisplayBetaRequester = TRUE;
  64. #endif
  65.  
  66. struct Window           *curwin = NULL;
  67. UBYTE                    curwinID = ROOT_WINDOW;
  68.  
  69.  
  70. #ifdef MUI
  71.  
  72. APTR                    *curwinobj = NULL;
  73.  
  74. #endif
  75.  
  76. #ifdef BGUI
  77.  
  78. Object                  *curwinobj = NULL;
  79. struct TextAttr          Attr;
  80. char                     FontName[50];
  81. int                      FontSize;
  82. struct TextFont         *TextFont = NULL;
  83. UBYTE                   *PubScreenName = NULL;
  84. ULONG                    appwinsigflag = 0;
  85.  
  86. #endif
  87.  
  88.  
  89.  
  90. IMPORT APTR App;
  91.  
  92.  
  93.  
  94. #ifdef GADTOOLS      /* GadTools Specific Code */
  95.  
  96. struct Screen   *Scr = NULL;
  97. UBYTE           *PubScreenName;
  98. APTR             VisualInfo = NULL;
  99. struct TextAttr *Font,Attr;
  100. UWORD            FontX,FontY; 
  101. UWORD            OffX,OffY;
  102. WORD             WindowTop = 0;
  103. WORD             WindowLeft = 0;
  104.  
  105. char  FontName[50];
  106. int   FontSize;
  107. static struct TextFont *TextFont=NULL;
  108.  
  109.  
  110.  
  111. int 
  112. SetupScreen(VOID)
  113. {
  114.     struct Screen *s;
  115.     ULONG lock;
  116.  
  117.     /* Choose a public screen to open our window */
  118.     lock = LockIBase(0);
  119.     s = IntuitionBase->ActiveScreen;
  120.     UnlockIBase(lock);
  121.   
  122.     PubScreenName = GetPubScreenName(s);
  123.  
  124.     if (! (Scr = LockPubScreen(PubScreenName)))
  125.         return(1L);
  126.  
  127.     ScreenToFront(Scr);
  128.  
  129.     ComputeFont(0,0);
  130.  
  131.     if (! (VisualInfo = GetVisualInfo(Scr,TAG_DONE)))
  132.         return(2L);
  133.  
  134.     return(0L);
  135. }
  136.  
  137.  
  138.  
  139. void 
  140. CloseDownScreen(VOID)
  141. {
  142.     if (VisualInfo) {
  143.         FreeVisualInfo(VisualInfo);
  144.         VisualInfo = NULL;
  145.     }
  146.  
  147.     if (Scr) {
  148.         UnlockPubScreen(NULL,Scr);
  149.         Scr = NULL;
  150.     }
  151. }
  152.  
  153.  
  154.  
  155. UWORD 
  156. ComputeX(UWORD value)
  157. {
  158.         return((UWORD)(((FontX*value)+4)/8));
  159. }
  160.  
  161.  
  162. UWORD 
  163. ComputeY(UWORD value)
  164. {
  165.         return((UWORD)(((FontY*value)+4)/8));
  166. }
  167.  
  168.  
  169. VOID
  170. UseTopaz(VOID)
  171. {
  172.     Font->ta_Name = (STRPTR)"topaz.font";
  173.     FontX = FontY = Font->ta_YSize = 8;
  174. }
  175.  
  176.  
  177. UWORD 
  178. CalcFontX(struct TextFont *TFont)
  179. {
  180.     static struct RastPort DummyRastPort;
  181.     UWORD                  result;
  182.  
  183.     if (TFont)
  184.     {
  185.         /* compute font width for the specified font */
  186.         SetFont(&DummyRastPort, TextFont);
  187.         result = (UWORD)TextLength(&DummyRastPort,"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",52)/52 ;
  188.     }
  189.     else
  190.     {
  191.         /* compute font width for screen font */
  192.         result = (UWORD)TextLength(&Scr->RastPort,"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",52)/52 ;
  193.     }
  194.     return(result);
  195. }
  196.  
  197.  
  198. VOID 
  199. ComputeFont(UWORD width,UWORD height)
  200. {
  201.     Font = &Attr;
  202.  
  203.     OffX = Scr->WBorLeft;
  204.     OffY = Scr->RastPort.TxHeight +Scr->WBorTop +1;
  205.  
  206.     if (strlen(FontName)>0)
  207.     {
  208.         Font->ta_Name = (STRPTR)FontName;
  209.         Font->ta_YSize = FontY = (UWORD)FontSize;
  210.     }
  211.     else
  212.     {
  213.         Font->ta_Name = (STRPTR)Scr->RastPort.Font->tf_Message.mn_Node.ln_Name;
  214.         Font->ta_YSize = FontY = Scr->RastPort.Font->tf_YSize;
  215.     }
  216.  
  217.     if (TextFont)
  218.     {
  219.         CloseFont(TextFont);
  220.     }
  221.  
  222.     TextFont = OpenDiskFont(Font);
  223.  
  224.     FontX = CalcFontX(TextFont);
  225.  
  226.     /* Don't go under 8 points */
  227.     if (FontY < 8) FontY = 8;
  228.  
  229.     if (width && height)
  230.     {
  231.         if (((ComputeX(width) + OffX + Scr->WBorRight) > Scr->Width) ||
  232.             ((ComputeY(height) + OffY + Scr->WBorBottom) > Scr->Height) ||
  233.             (TextFont == NULL))
  234.         {
  235.             UseTopaz();
  236.         }
  237.     }
  238. }
  239.  
  240.  
  241.  
  242. __regargs void
  243. DrawThinBevelBox(struct Screen *Screen, struct RastPort *rp,
  244.                                  long Left, long Top, long Width, long Height, BOOL Recess)
  245. {
  246.     struct DrawInfo *ScreenDrawInfo;
  247.  
  248.     ScreenDrawInfo = GetScreenDrawInfo(Screen);
  249.     SetAPen(rp, ScreenDrawInfo->dri_Pens[(Recess) ? SHADOWPEN : SHINEPEN]);
  250.     Move(rp, Left, Top + Height - 1);
  251.     Draw(rp, Left, Top);
  252.     Draw(rp, Left + Width - 1, Top);
  253.     SetAPen(rp, ScreenDrawInfo->dri_Pens[(Recess) ? SHINEPEN : SHADOWPEN]);
  254.     Draw(rp, Left + Width - 1, Top + Height - 1);
  255.     Draw(rp, Left + 1, Top + Height - 1);
  256.     FreeScreenDrawInfo(Screen, ScreenDrawInfo);
  257. }
  258.  
  259.  
  260. /* Localize gadget labels, locale strings identifiers are stored in UserData filed */
  261. __regargs void
  262. LocalizeNGadLabels (UBYTE Gadgets_Num, struct NewGadget *NGad)
  263. {
  264.     UWORD i;
  265.  
  266.     for (i=0; i<Gadgets_Num; i++)
  267.     {
  268.         if (NGad[i].ng_UserData)
  269.         {
  270.             NGad[i].ng_GadgetText = getString(NGad[i].ng_UserData);
  271.         }
  272.     }
  273. }
  274.  
  275.  
  276. static __regargs VOID
  277. SetWindowUnderMouse (UWORD Width, UWORD Height, WORD *Left, WORD *Top)
  278. {
  279.     WORD MouseY, MouseX;
  280.  
  281.     /* Where is our mouse pointer? */
  282.     MouseX = Scr->MouseX;
  283.     MouseY = Scr->MouseY;
  284.  
  285.     /* Is our pointer above the window to open ? */
  286.     if ((MouseX >= *Left) && (MouseX <= (*Left+Width)) &&
  287.         (MouseY >= *Top) && (MouseY <= (*Top+Height)))
  288.     {
  289.         /* Yes, so we don't have to move our window */
  290.     }
  291.     else
  292.     {
  293.         /* No, so we have to move our window only by what is needed */
  294.  
  295.         if ((MouseX < *Left) || (MouseX > (*Left+Width)))
  296.             *Left = MouseX - Width;
  297.  
  298.         if ((MouseY < *Top) || (MouseY > (*Top+Height)))
  299.             *Top = MouseY - Height;
  300.     }
  301.  
  302. }
  303.  
  304. __regargs void
  305. SetUpWindowCoordinates( UWORD Width, UWORD Height, WORD *Left, WORD *Top)
  306. {
  307.  
  308.     struct IBox     box;
  309.  
  310.     /* If AutoPoint is enabled, we want the window to be openned 
  311.      * under mouse pointer 
  312.      */
  313.     if (autopoint)
  314.         SetWindowUnderMouse (Width, Height, Left, Top);
  315.     
  316.     /* Check boundaries, especially for autoscroll screens */
  317.  
  318.     GetScreenBox(Scr, &box, TRUE);
  319.  
  320.     if (*Left < box.Left) 
  321.         *Left = box.Left;
  322.     if (*Top < box.Top) 
  323.         *Top = box.Top;
  324.     if ((*Left + Width) > box.Left + box.Width) 
  325.         *Left = box.Left + box.Width - Width;
  326.     if ((*Top +  Height) > box.Top + box.Height) 
  327.         *Top = box.Top + box.Height - Height;
  328. }
  329.  
  330. #endif  /* GadTools Specific Code */
  331.  
  332. #ifdef BGUI                                     /* BGUI specific code NMC */
  333. int SetupScreen(VOID)
  334. {
  335.     struct Screen *s;
  336.     ULONG lock;
  337.  
  338.     /* Choose a public screen to open our window */
  339.     lock = LockIBase(0);
  340.     s = IntuitionBase->ActiveScreen;
  341.     UnlockIBase(lock);
  342.   
  343.     PubScreenName = GetPubScreenName(s);
  344.  
  345.     return(0L);
  346. }
  347. #endif
  348.  
  349. /* initialise individual gadget in specified window */
  350. #ifdef GADTOOLS    /* GadTools Version */
  351. __regargs void
  352. InitWindowGadget(UWORD num, LONG tagtype, LONG tagvalue, UBYTE WindowID)
  353. {
  354.     switch(WindowID)
  355.     {
  356.       case ROOT_WINDOW:
  357.         GT_SetGadgetAttrs(RootGadgets[num], RootWnd, NULL, tagtype, tagvalue, TAG_DONE);
  358.         break;
  359.  
  360.       case HOTKEY_WINDOW:
  361.         GT_SetGadgetAttrs(HotKeyGadgets[num], HotKeyWnd, NULL, tagtype, tagvalue, TAG_DONE);
  362.         break;
  363.  
  364.       case MISC_WINDOW:
  365.         GT_SetGadgetAttrs(MiscGadgets[num], MiscWnd, NULL, tagtype, tagvalue, TAG_DONE);
  366.         break;
  367.  
  368.       case BLANK_WINDOW:
  369.         GT_SetGadgetAttrs(BlankGadgets[num], BlankWnd, NULL, tagtype, tagvalue, TAG_DONE);
  370.         break;
  371.  
  372.       case MCYCLING_WINDOW:
  373.         GT_SetGadgetAttrs(MouseCyclingGadgets[num], MouseCyclingWnd, NULL, tagtype, tagvalue, TAG_DONE);
  374.         break;
  375.  
  376.       case KEYDEF_WINDOW:
  377.         GT_SetGadgetAttrs(KeyDefGadgets[num], KeyDefWnd, NULL, tagtype, tagvalue, TAG_DONE);
  378.         break;
  379.  
  380.       case DIGITALCLOCK_WINDOW:
  381.         GT_SetGadgetAttrs(DigitalClockGadgets[num], DigitalClockWnd, NULL, tagtype, tagvalue, TAG_DONE);
  382.         break;
  383.     }
  384. }
  385.  
  386. #endif
  387. #ifdef MUI           /* MUI version */
  388. __regargs void
  389. InitWindowGadget(UWORD num, LONG tagtype, LONG tagvalue, UBYTE WindowID)
  390. {
  391.     switch(WindowID)
  392.     {
  393.       case ROOT_WINDOW:
  394.         SetAttrs(RootObjects[num], MUIA_NoNotify, TRUE, tagtype, tagvalue, TAG_DONE);
  395.         break;
  396.  
  397.       case HOTKEY_WINDOW:
  398.         SetAttrs(HotKeyObjects[num], MUIA_NoNotify, TRUE, tagtype, tagvalue, TAG_DONE);
  399.         break;
  400.  
  401.       case MISC_WINDOW:
  402.         SetAttrs(MiscObjects[num], MUIA_NoNotify, TRUE, tagtype, tagvalue, TAG_DONE);
  403.         break;
  404.  
  405.       case BLANK_WINDOW:
  406.         SetAttrs(BlankObjects[num], MUIA_NoNotify, TRUE, tagtype, tagvalue, TAG_DONE);
  407.         break;
  408.  
  409.       case MCYCLING_WINDOW:
  410.         SetAttrs(MouseCyclingObjects[num], MUIA_NoNotify, TRUE, tagtype, tagvalue, TAG_DONE);
  411.         break;
  412.  
  413.       case KEYDEF_WINDOW:
  414.         SetAttrs(KeyDefObjects[num], MUIA_NoNotify, TRUE, tagtype, tagvalue, TAG_DONE);
  415.         break;
  416.     }
  417. }
  418.  
  419. #endif
  420. #ifdef BGUI           /* BGUI version  NMC */
  421. __regargs void
  422. InitWindowGadget(UWORD num, LONG tagtype, LONG tagvalue, UBYTE WindowID)
  423. {
  424.     switch(WindowID)
  425.     {
  426.       case ROOT_WINDOW:
  427.         SetGadgetAttrs((struct Gadget *)RootObjects[num], RootWnd, NULL,
  428.                         tagtype, tagvalue, TAG_DONE);
  429.         break;
  430.  
  431.       case BLANK_WINDOW:
  432.         SetGadgetAttrs((struct Gadget *)BlankObjects[num], BlankWnd, NULL,
  433.                         tagtype, tagvalue, TAG_DONE);
  434.         break;
  435.  
  436.       case MISC_WINDOW:
  437.         SetGadgetAttrs((struct Gadget *)MiscObjects[num], MiscWnd, NULL,
  438.                         tagtype, tagvalue, TAG_DONE);
  439.         break;
  440.  
  441.       case MCYCLING_WINDOW:
  442.         SetGadgetAttrs((struct Gadget *)MouseCyclingObjects[num], MouseCyclingWnd, NULL,
  443.                         tagtype, tagvalue, TAG_DONE);
  444.         break;
  445.  
  446.       case HOTKEY_WINDOW:
  447.         SetGadgetAttrs((struct Gadget *)HotKeyObjects[num], HotKeyWnd, NULL,
  448.                         tagtype, tagvalue, TAG_DONE);
  449.         break;
  450.  
  451.       case KEYDEF_WINDOW:
  452.         SetGadgetAttrs((struct Gadget *)KeyDefObjects[num], KeyDefWnd, NULL,
  453.                         tagtype, tagvalue, TAG_DONE);
  454.         break;
  455.  
  456.       case DIGITALCLOCK_WINDOW:
  457.         SetGadgetAttrs((struct Gadget *)DigitalClockObjects[num], DigitalClockWnd, NULL,
  458.                         tagtype, tagvalue, TAG_DONE);
  459.         break;
  460.     }
  461. }
  462.  
  463. #endif
  464.  
  465.  
  466.  
  467. /* Init Toggles: Shared Code */
  468. #ifdef GADTOOLS
  469. #    define CHECKMARK_TAG GTCB_Checked
  470. #endif
  471. #ifdef MUI
  472. #    define CHECKMARK_TAG MUIA_Selected
  473. #endif
  474. #ifdef BGUI             /* NMC */
  475. #    define CHECKMARK_TAG GA_Selected
  476. #endif
  477.  
  478. __regargs void
  479. InitToggleGadgets( UBYTE WindowID )
  480. {
  481.     UWORD   i;
  482.     for (i = 0; i < NUM_TOGGLES; i++)
  483.         if ((toggles[i].gadid != OBSOLETE_TOGGLE) &&
  484.             (toggles[i].winid == WindowID))
  485.         {
  486.             InitWindowGadget(toggles[i].gadid,
  487.                              CHECKMARK_TAG,
  488.                              toggles[i].pos,
  489.                              WindowID); 
  490.         }
  491. }
  492.  
  493.  
  494.  
  495. /* Handle pattern string-gadget */
  496. #ifdef GADTOOLS   /* GadTools Version */
  497. __regargs void
  498. NewPattern(UWORD gdx, PatternData *pdata, struct Gadget *gad, UBYTE WindowID)
  499. {
  500.     char *newpatstr;
  501.  
  502.     newpatstr = GetString(gad);
  503.     if (!InitPattern(newpatstr, pdata))
  504.     {
  505.         InitWindowGadget(gdx, GTST_String, (LONG)pdata->patstr, WindowID);
  506.     }
  507. }
  508. #endif
  509. #ifdef MUI           /* MUI Version */
  510. __regargs void
  511. NewPattern(UWORD gdx, PatternData *pdata, struct Gadget *gad, UBYTE WindowID)
  512. {
  513.     char *newpatstr;
  514.  
  515.     GetAttr(MUIA_String_Contents, gad, (ULONG *)&newpatstr);
  516.     if (!InitPattern(newpatstr, pdata))
  517.     {
  518.         InitWindowGadget(gdx, MUIA_String_Contents, (LONG)pdata->patstr, WindowID);
  519.     }
  520. }
  521. #endif
  522. #ifdef BGUI           /* BGUI Version NMC */
  523. __regargs void
  524. NewPattern(UWORD gdx, PatternData *pdata, struct Gadget *gad, UBYTE WindowID)
  525. {
  526.     char *newpatstr;
  527.  
  528.     GetAttr(STRINGA_TextVal, gad, (ULONG *)&newpatstr);
  529.     if (!InitPattern(newpatstr, pdata))
  530.     {
  531.         InitWindowGadget(gdx, STRINGA_TextVal, (LONG)pdata->patstr, WindowID);
  532.     }
  533. }
  534. #endif
  535.  
  536.  
  537.  
  538. /* Disable/Enable the GUI */
  539. #ifdef GADTOOLS   /* GadTools Version */
  540.  
  541. /* Wait pointer image data */
  542. __chip static UWORD WaitPointer[] = {
  543.         0x0000, 0x0000,
  544.         0x0400, 0x07c0, 
  545.         0x0000, 0x07c0, 
  546.         0x0100, 0x0380, 
  547.         0x0000, 0x07e0, 
  548.         0x07c0, 0x1ff8,
  549.         0x1ff0, 0x3fec, 
  550.         0x3ff8, 0x7fde, 
  551.         0x3ff8, 0x7fbe, 
  552.         0x7ffc, 0xff7f, 
  553.         0x7efc, 0xffff,
  554.         0x7ffc, 0xffff, 
  555.         0x3ff8, 0x7ffe, 
  556.         0x3ff8, 0x7ffe, 
  557.         0x1ff0, 0x3ffc, 
  558.         0x07c0, 0x1ff8,
  559.         0x0000, 0x07e0,
  560.  
  561.         0x0000, 0x0000
  562. };
  563.  
  564. static struct Requester DummyReq;
  565. static ULONG  IDCMPFlags;
  566.  
  567.  
  568. void 
  569. DisableYakInterface(VOID)
  570. {
  571.     if (curwin)
  572.     {
  573.         /* Disable IDCMP */
  574.         IDCMPFlags = ((struct Window *)curwin)->IDCMPFlags;
  575.         ModifyIDCMP(curwin, IDCMP_REFRESHWINDOW);
  576.  
  577.         /* Init dummy requester structure */
  578.         InitRequester(&DummyReq);
  579.  
  580.         /* Block window input */
  581.         Request(&DummyReq, curwin);
  582.  
  583.         /* Set wait pointer */
  584.         if (SysBase->LibNode.lib_Version >= 39)
  585.             SetWindowPointer(curwin, WA_BusyPointer, TRUE, TAG_DONE);
  586.         else
  587.             SetPointer(curwin, WaitPointer, 16, 16, -6, 0);
  588.     }
  589. }
  590.  
  591.  
  592. void 
  593. EnableYakInterface(VOID)
  594. {
  595.     /* Clear wait pointer */
  596.     if (SysBase->LibNode.lib_Version >= 39)
  597.         SetWindowPointer(curwin, TAG_DONE);
  598.     else
  599.         ClearPointer(curwin);
  600.  
  601.     /* Enable window input */
  602.     EndRequest(&DummyReq, curwin);
  603.  
  604.     /* Enable IDCMP */
  605.     ModifyIDCMP(curwin, IDCMPFlags);
  606. }
  607.  
  608. #endif
  609. #ifdef MUI        /* MUI Version */
  610.  
  611. void 
  612. DisableYakInterface(VOID)
  613. {
  614.     set(App, MUIA_Application_Sleep, TRUE);
  615. }
  616.  
  617.  
  618. void 
  619. EnableYakInterface(VOID)
  620. {
  621.     set(App, MUIA_Application_Sleep, FALSE);
  622. }
  623.  
  624. #endif
  625. #ifdef BGUI        /* BGUI Version NMC */
  626. void 
  627. DisableYakInterface(VOID)
  628. {
  629.         WindowBusy(curwinobj);
  630. }
  631.  
  632.  
  633. void 
  634. EnableYakInterface(VOID)
  635. {
  636.         WindowReady(curwinobj);
  637. }
  638. #endif
  639.  
  640.  
  641. /* show current window */
  642. BOOL
  643. ShowYakInterface(VOID)
  644. {
  645.     BOOL OK;
  646.         
  647. #ifdef BETA_VERSION
  648.     if (DisplayBetaRequester == TRUE)
  649.     {
  650.         PostError("This is " VERSION_NAME " beta version\nBuilt on " __DATE__);
  651.         DisplayBetaRequester = FALSE;
  652.     }
  653. #endif
  654.  
  655.     if (curwin)             /* already opened */
  656.     {
  657.        ScreenToFront(((struct Window *)curwin)->WScreen);
  658.        WindowToFront(curwin);
  659.        ActivateWindow(curwin);
  660.        return TRUE;
  661.     }
  662.  
  663. #ifndef MUI
  664.     if (!(OK=SetupScreen()))
  665.     {
  666.        OK = ShowWindowID(curwinID);
  667.     }
  668. #else
  669.        OK = ShowWindowID(curwinID);
  670. #endif
  671.  
  672.     if (!OK)
  673.         PostError(getString(Couldnt_open_GUI_ERR));
  674.     return(OK);
  675. }
  676.  
  677.  
  678.  
  679.  
  680. BOOL
  681. ShowWindowID(UBYTE WindowID)
  682. {
  683.     BOOL OK;
  684.  
  685.     switch(WindowID)
  686.     {
  687.       case ROOT_WINDOW:
  688.         OK = ShowRootWindow();
  689.         break;
  690.  
  691.       case HOTKEY_WINDOW:
  692.         OK = ShowHotKeyWindow();
  693.         break;
  694.  
  695.       case MISC_WINDOW:
  696.         OK = ShowMiscWindow();
  697.         break;
  698.  
  699.       case BLANK_WINDOW:
  700.         OK = ShowBlankWindow();
  701.         break;
  702.  
  703.       case MCYCLING_WINDOW:
  704.         OK = ShowMouseCyclingWindow();
  705.         break;
  706.  
  707.       case KEYDEF_WINDOW:
  708.         OK = ShowKeyDefWindow();
  709.         break;
  710.         
  711.       case OPTIONS_WINDOW:
  712.         OK = ShowOptionsWindow();
  713.         break;
  714.  
  715.       case DIGITALCLOCK_WINDOW:
  716.         OK = ShowDigitalClockWindow();
  717.         break;
  718.         
  719.     }
  720.  
  721.     if (OK)
  722.     {
  723.         ActivateWindow(curwin);
  724.     }
  725.     else
  726.     {
  727.         PostError(getString(Couldnt_open_other_window_ERR));
  728.     }
  729.     return(OK);
  730. }
  731.  
  732.  
  733. VOID 
  734. CloseWindowID(UBYTE WindowID)
  735. {
  736.     switch(WindowID)
  737.     {
  738.       case ROOT_WINDOW:
  739.         CloseRootWindow();
  740.         break;
  741.  
  742.       case HOTKEY_WINDOW:
  743.         CloseHotKeyWindow();
  744.         break;
  745.  
  746.       case MISC_WINDOW:
  747.         CloseMiscWindow();
  748.         break;
  749.  
  750.       case BLANK_WINDOW:
  751.         CloseBlankWindow();
  752.         break;
  753.  
  754.       case KEYDEF_WINDOW:
  755.         CloseKeyDefWindow();
  756.         break;
  757.  
  758.       case MCYCLING_WINDOW:
  759.         CloseMouseCyclingWindow();
  760.         break;
  761.         
  762.       case OPTIONS_WINDOW:
  763.         CloseOptionsWindow();
  764.         break;
  765.  
  766.       case DIGITALCLOCK_WINDOW:
  767.         CloseDigitalClockWindow();
  768.         break;
  769.         
  770.     }
  771.  
  772.     curwin = NULL;
  773. #if defined(MUI) || defined(BGUI)
  774.     curwinobj = NULL;
  775. #endif
  776. }
  777.  
  778.  
  779. #ifdef GADTOOLS   /* GadTools Version */
  780. void
  781. CloseOneWindow (struct Window *Wnd, 
  782.                 struct Menu *Menus, struct Gadget *GList, struct AppWindow *AppWin)
  783. {
  784.     /* Save coordinates of current window */
  785.  
  786.     WindowTop  = Wnd->TopEdge;
  787.     WindowLeft = Wnd->LeftEdge;
  788.  
  789.     if (AppWin)
  790.     {
  791.         RemoveAppWindow(AppWin);
  792.     }
  793.  
  794.     FreeMenus(Menus);
  795.  
  796.     if (Wnd) 
  797.     {
  798.         ClearMenuStrip(Wnd);
  799.         CloseWindow(Wnd);
  800.     }
  801.     
  802.     FreeGadgets(GList);
  803. }
  804.  
  805. #endif
  806. #ifdef MUI       /* MUI Version */
  807. #endif
  808. #ifdef BGUI      /* BGUI Version NMC */
  809. #endif
  810.  
  811.  
  812. /* hide our window */
  813. void
  814. HideInterface(VOID)
  815. {
  816.     if (curwin)
  817.     {
  818.         CloseWindowID(curwinID);
  819. #ifdef GADTOOLS
  820.         CloseDownScreen();
  821. #endif
  822.     }
  823. #ifdef GADTOOLS
  824.     if (TextFont)
  825.     {
  826.         CloseFont(TextFont);
  827.     }
  828. #endif
  829. }
  830.  
  831.